package com.isd.inventario.web;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import com.isd.facturacion.modelo.ItemProductoTienda;
import com.isd.facturacion.rn.MovimientoFacturacionRN;
import com.isd.facturacion.web.CarritoBean;
import com.isd.global.util.JsfUtil;
import com.isd.global.web.MonedaBean;
import com.isd.inventario.modelo.ItemBusquedaPredefinida;
import com.isd.inventario.modelo.Producto;
import com.isd.inventario.modelo.Relacionado;
import com.isd.inventario.modelo.Sustitutos;
import com.isd.inventario.rn.ItemBusquedaPredefinidaRN;
import com.isd.inventario.rn.ListaPrecioRN;
import com.isd.inventario.rn.ProductoRN;
import com.isd.inventario.rn.RubroClienteRN;
import com.isd.inventario.vista.ItemCatalogo;
import com.isd.seguridad.modelo.ProductoFavorito;
import com.isd.seguridad.web.UsuarioSessionBean;
import java.io.IOException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.SessionScoped;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import org.primefaces.component.datagrid.DataGrid;
import org.primefaces.component.datatable.DataTable;
import org.primefaces.model.TreeNode;

/**
 *
 * @author Claudio
 */
@ManagedBean(name="catalogoBean")
@SessionScoped
public class CatalogoBean implements Serializable {

    @EJB private ListaPrecioRN listaPrecioRN;
    @EJB private RubroClienteRN rubroClienteRN;
    @EJB private ProductoRN productoRN;    
    @EJB private MovimientoFacturacionRN movimientoFacturacionRN;
    @EJB private ItemBusquedaPredefinidaRN itemBusquedaPredefinidaRN;

    private List<ItemCatalogo> catalogo;
    private List<String> tiposProductos;
    private List<String> subTipos;
    private List<String> marcas;        
    
    private List<ItemBusquedaPredefinida> itemsBusqueda;

    Map<String,String> filtro;
    Map<String,String> filtroRubros;
    private String selecionActual;
    private int cantidadRegistros;

    private BigDecimal porcMarcacion;
    private ItemCatalogo itemCatalogo;

    //Objetos utilizados para los filtros
    private String tipoProducto;
    private String subTipo;
    private String marca;    
    private boolean importado;
    private boolean nacional;
    private boolean nuevo;
    private boolean precioActualizado;    
    private String txtDescripcion;
    
    
    private String nrocta;
    private boolean esVendedor;
    private boolean muestraPrincipal;
    private boolean muestraPanelMarcacion;
    private boolean muestraConversorMedida;
    private boolean muestraPanelDescarga;
    private String tipoVista;

    @ManagedProperty(value = "#{carritoBean}")
    private CarritoBean carritoBean;
    
    @ManagedProperty(value = "#{monedaBean}")
    private MonedaBean monedaBean;

    @ManagedProperty(value = "#{usuarioSessionBean}")
    private UsuarioSessionBean usuarioSessionBean;

    //Prueba menu con arbol
    private TreeNode root;
    private TreeNode selectedNode;

    private String productId;

    /** Creates a new instance of CatalogoBean */
    public CatalogoBean() {
        
    }

    @PostConstruct
    public void init(){
        
        esVendedor = false;
        porcMarcacion = BigDecimal.ZERO;
        muestraPanelMarcacion = false;
        muestraConversorMedida = false;
        muestraPanelDescarga = false;
        
        //muestraSugerencia
        muestraPrincipal = true;

        marcas = new ArrayList<String>();
        subTipos = new ArrayList<String>();                

        filtro = new HashMap<String,String>();
        filtroRubros = new HashMap<String,String>();
        itemCatalogo = new ItemCatalogo();
        catalogo = new ArrayList<ItemCatalogo>();
        
        itemsBusqueda = itemBusquedaPredefinidaRN.getLista();

        if(usuarioSessionBean.isEstaRegistrado()){
            tipoVista = usuarioSessionBean.getUsuario().getTipoVista();

            //Seteamos bandera si el susuario logeado es vendedor
            if(usuarioSessionBean.getUsuario().getNombre()!=null){
                if(usuarioSessionBean.getUsuario().getTipo().equals('V')){
                    esVendedor = true;
                }
            }
        }else{
            tipoVista = usuarioSessionBean.getUsuario().getTipoVista();
        }
    }
    
    public void cargarCatalogo() throws IOException{     

//        System.err.println("*********** CARGAR CATALOGO ******************");
        
        //Si no existe usuario logeado asignamos el usuario por defecto para visualizar el catálogo publico
        if (usuarioSessionBean.isEstaRegistrado()){
            
            if(usuarioSessionBean.getUsuario().getCliente()!=null){
                nrocta = usuarioSessionBean.getUsuario().getCliente().getNrocta();
            }else{                
                if(esVendedor){  
                    JsfUtil.addErrorMessage("Seleccione un cliente por favor");                    
                    //FacesContext.getCurrentInstance().getExternalContext().redirect("../ventas/seleccionarCliente.jsf");                        
                    return;
                    
                }
                nrocta = "999999";
            }
        }else{            
            JsfUtil.addWarningMessage("Para visualizar los precios debe inciar sessión");
            nrocta = "999999";            
        }
        
        cargarFiltroRubros();

        if(tiposProductos==null ){
            tiposProductos = rubroClienteRN.getTipoProductoByNrocta(filtroRubros);            
        }else if(tiposProductos.isEmpty()){
            tiposProductos = rubroClienteRN.getTipoProductoByNrocta(filtroRubros);            
        }
        
        if(marcas==null){            
            marcas = rubroClienteRN.getMarcaByNroCta(filtroRubros);                        
        }else if(marcas.isEmpty()){
            marcas = rubroClienteRN.getMarcaByNroCta(filtroRubros);            
        }

        //Si está registrado buscamos el carrito de lo contrario vamos al catálogo
        if(usuarioSessionBean.isEstaRegistrado() && usuarioSessionBean.getUsuario().getCliente()!=null){
            
            if(carritoBean.getCarrito()==null){
                
                if(carritoBean.tengoVariosCarrito()){                    
                    
                    JsfUtil.addWarningMessage("Usted posee más de un carrito sin confirmar");
                    ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();                    
                    context.redirect("../facturacion/carritoLista.jsf");  
                    return;
                }
                
                if(carritoBean.getListaCarrito().size() == 1) {
                   carritoBean.setCarrito(carritoBean.getListaCarrito().get(0));
                   JsfUtil.addInfoMessage("Se ha recuperado el último carrito sin confirmar");
                }else{
                    if(usuarioSessionBean.getUsuario().getTipo().equals('V')){
                        carritoBean.generarCarritoVendedor();
                    }else{
                        carritoBean.generarCarritoCliente();
                    }
                }
            }            
            marcarSeleccionados(carritoBean.getCarrito().getItemsProducto());           
        }        
        marcarFavoritoEnCatalogo();
    }
    
    public void cargarProducto(){

        if (productId!=null){
            
            if(!productId.isEmpty()){
                init();
                //String verCatalogo = verCatalogo();        
                txtDescripcion = productId;
                verProductos();
            }
        }
        productId=null;                    
    }

    public void guardarUltimaVista(){

        if(usuarioSessionBean.isEstaRegistrado()){

            usuarioSessionBean.getUsuario().setTipoVista(tipoVista);
            usuarioSessionBean.guardar();
        }
    }

    /**
     * Volvemos a la viste de catálogo
     */
    public void volverCatalogo(){
        
        tipoVista = usuarioSessionBean.getUsuario().getTipoVista();     
    }
    
    public String verCatalogo(){
        return "/inventario/catalogo.xhtml?faces-redirect=true";
    }

    /*
     * @param tp Tipo de producto
     * @return  
     */
 
    public String verProductosFromCatalogoHome(String tipo,String mar){
        
        if(mar!=null) this.marca = mar;
        if(tipo!=null) tipoProducto = tipo;        
        verProductosByRubro(true);        
        return verCatalogo();
    }
    
    public void verProductosByRubro(boolean limpiaFiltros){
        
        //Limpiamos los filtros previos     
        if (limpiaFiltros){
            
            importado = false;
            nacional = false;
            nuevo = false;                    
        }
        
        cargarFiltroRubros();
        
        tiposProductos = rubroClienteRN.getTipoProductoByNrocta(filtroRubros);
        marcas = rubroClienteRN.getMarcaByNroCta(filtroRubros);     
        subTipos = rubroClienteRN.getSubtipoByNrocta(filtroRubros);        
        verProductos();
    }   
   

    public void verProductos(){
        
        tipoVista = usuarioSessionBean.getUsuario().getTipoVista();     

        //Seteamos la bandera para que no muestre mas las sugerencias del inicio
        muestraPrincipal = false;        
        
        cargarFiltroCatalogo(filtro);

        cantidadRegistros = 0;
        catalogo = listaPrecioRN.getItemCatalogo(1,500,null,null, filtro);

        if(usuarioSessionBean.isEstaRegistrado() && carritoBean.getCarrito()!= null){
            marcarSeleccionados(carritoBean.getCarrito().getItemsProducto());
            marcarFavoritoEnCatalogo();
        }
        
        cantidadRegistros = catalogo.size();
        
//        cantidadRegistros = listaPrecioRN.getCantidadItemCatalogo(filtro);

        //Volvemos a la posición 1, el paginador si la vista está en detalle
        try {
            if (tipoVista.equals("T")) {
                
                DataTable d = (DataTable) FacesContext.getCurrentInstance().getViewRoot().findComponent("formulario").findComponent("tCatalogo");                
                if (d != null) {
                    d.setFirst(0);
                }
            }

            //Volvemos a la posición el paginador si la vista está en paneles
            if (tipoVista.equals("P")) {
                DataGrid d = (DataGrid) FacesContext.getCurrentInstance().getViewRoot().findComponent("formulario").findComponent("dgCatalogo");
                
                if (d != null) {
                    d.setFirst(0);
                }                
            }
        } catch (Exception e) {
        }
        
        if(cantidadRegistros==0) JsfUtil.addInfoMessage("No se encontraron productos que coincidan con su búsqueda. l/ "
                + "Intente LIMPIAR FILTROS y repita la búsqueda.");
    }
    
    private void cargarFiltroCatalogo(Map<String, String> filtro) {

        filtro.clear();
        selecionActual = "";

        /**Si es un usuario cliente filtramos solamente los productos
         * que están disponibles para la web, si es un usuario vendedor
         * le mostramos todos los productos
         */
        if(!usuarioSessionBean.getUsuario().getTipo().equals('V')){
            filtro.put("diponibleEnInternet = ", "'S'");
        }

        if (usuarioSessionBean.getUsuario().getCliente()==null){
            filtro.put("nrocta = ", "'999999'");
        }else{
            filtro.put("nrocta = ", "'"+usuarioSessionBean.getUsuario().getCliente().getNrocta()+"'");
        }

        if (tipoProducto!=null){
            if(!tipoProducto.isEmpty()){
                filtro.put("tipoProducto = ", "'"+tipoProducto+"'");
            }
        }

        if(subTipo!=null){
            if(!subTipo.isEmpty()){
                filtro.put("subtipo = ", "'"+subTipo+"'");
            }
        }

        if(marca!=null){
            if(!marca.isEmpty()){
                filtro.put("marca = ", "'" + marca+ "'");
            }
        }

        if(nuevo){
            filtro.put("pnuevo = ", "'S'");
        }else{
            //filtro.put("pnuevo <>", "'S'");
        }

        if(importado){
            filtro.put("importado = ",  "'S'");
        }else{        
            //filtro.put("importado <> ", "'S'");
        }
        
        if(nacional){
            filtro.put("importado = ",  "'N'");
        }else{        
            //filtro.put("importado <> ", "'S'");
        }
        
        if(precioActualizado){
            filtro.put("conVariacionPrecio = ",  "'S'");
        }else{        
            //filtro.put("conVariacionPrecio <> ", "'S'");
        }
        
        if(txtDescripcion!=null){
            if(!txtDescripcion.isEmpty()){

                String sfiltro = "descrp LIKE '%" + txtDescripcion+ "%'  "
                + "  OR (i.clave LIKE '%" + txtDescripcion+ "%') "
                + "  OR (i.artcod LIKE '%" + txtDescripcion+ "%') "
                + "  OR (i.indcod LIKE '%" + txtDescripcion+"%') "
                + "  OR (i.tipoProducto LIKE '%" + txtDescripcion+ "%') "
                + "  OR (i.marca LIKE '%" + txtDescripcion+"%') "                
                + "  OR (i.subtipo LIKE '%" + txtDescripcion+"%') "
                + "  OR (i.nroParte LIKE '%" + txtDescripcion+"%') ";

                filtro.put(sfiltro, "" );

                
            }
        }
    }

    /** Filtramos los rubros disponibles para el cliente logeado
     * o en su defecto para el publico
     *
     * @param filtro
     */
    private void cargarFiltroRubros() {
        
//        System.err.println("*********** cargarFiltroRubros ******************");

        filtroRubros.clear();
        selecionActual = "";

        /**Si es un usuario cliente filtramos solamente los productos
        * que están disponibles para la web, si es un usuario vendedor
        * le mostramos todos los productos
        */
        
        if(!usuarioSessionBean.getUsuario().getTipo().equals('V')){
            filtroRubros.put("diponibleEnInternet = ", "'S'");
        }

        if (usuarioSessionBean.getUsuario().getCliente()==null){
            filtroRubros.put("nrocta = ", "'999999'");
        }else{
            filtroRubros.put("nrocta = ", "'"+usuarioSessionBean.getUsuario().getCliente().getNrocta()+"'");
        }
        
        if (tipoProducto!=null){
            if(!tipoProducto.isEmpty()){
                filtroRubros.put("tipo = ", "'"+tipoProducto+"'");
            }
        }

        if(subTipo!=null){
            if(!subTipo.isEmpty()){
                filtroRubros.put("subtipo = ", "'"+subTipo+"'");
            }
        }

        if(marca!=null){
            if(!marca.isEmpty()){
                filtroRubros.put("marca = ", "'" + marca+ "'");
            }
        }        
    }

    public void limpiarFiltros(){

        tipoProducto = null;
        subTipo = null;
        marca = null;
        importado = false;
        nacional = false;
        nuevo = false;
        precioActualizado = false;
        txtDescripcion = "";
        subTipos.clear();
        marcas.clear();        
        
        verProductosByRubro(true);
    }
  
   /** Marcamos los productos del catálogo como comprados 
     * @param items
    */
    public void marcarSeleccionados(List<ItemProductoTienda> items){

        if (catalogo==null) return;
        if (items==null) return;

        int cantItems = items.size();        
        int contadorItemsCarrito = 0;
        
        for(ItemCatalogo itmCat: catalogo){
            
            itmCat.setSeleccionado(false);
            itmCat.setFavorito(false);            
            
            //Seleccionados en el carrito
            for(ItemProductoTienda item: items){
                if(item.getProducto()!=null){
                    if(itmCat.getTippro().equals(item.getProducto().getTippro()) &&
                       itmCat.getArtcod().equals(item.getProducto().getArtcod())){

                        itmCat.setSeleccionado(true);
                        contadorItemsCarrito++;

                        if(contadorItemsCarrito==cantItems) return;
                    }
                }
            }            
        }
    }

    public void marcarFavoritoEnCatalogo(){
        
        if (catalogo==null) return;
        if (usuarioSessionBean.getUsuario().getFavoritos()==null) return;
                
        int cantFavoritos = usuarioSessionBean.getUsuario().getFavoritos().size();
        
        int contadorItemsFavoritos = 0;

        for(ItemCatalogo itmCat: catalogo){
        
            itmCat.setFavorito(false);                        
            
            //Marcamos los favoritos
            for(ProductoFavorito f: usuarioSessionBean.getUsuario().getFavoritos()){
                
                if(f.getProducto()!=null){
                    if(itmCat.getTippro().equals(f.getProducto().getTippro()) &&
                       itmCat.getArtcod().equals(f.getProducto().getArtcod())){

                        itmCat.setFavorito(true);
                        contadorItemsFavoritos++;

                        if(contadorItemsFavoritos==cantFavoritos) return;
                    }
                }                
            }            
        }        
    }
    
    public void marcarProductoSeleccionado(Producto p){
                
        if (!usuarioSessionBean.isEstaRegistrado()) return;
        if (p==null) return;
        if (catalogo==null) return;        
        if (carritoBean.getCarrito()==null) return;
               

        for(ItemProductoTienda i: carritoBean.getCarrito().getItemsProducto()){

            if(i.getProducto().getProductoPK().getTippro().equals(p.getProductoPK().getTippro())
            && i.getProducto().getProductoPK().getArtcod().equals(p.getArtcod())){

                itemCatalogo.setSeleccionado(true);
            }
            
            //Marcamos como comprado si existe algún producto de los sustitutos
            if(p.getSustitutos()!=null){
                for(Sustitutos s:p.getSustitutos()){                    
                    if(i.getProducto().getProductoPK().getTippro().equals(s.getSustitutosPK().getTipsus())
                    && i.getProducto().getProductoPK().getArtcod().equals(s.getSustitutosPK().getArtsus())){

                        s.setSeleccionado(true);
                    }                    
                }
            }
            
            //Marcamos como comprado si existe algún producto de los sugeridos
            if(p.getRelacionados()!=null){
                for(Relacionado r: p.getRelacionados()){                    
                    if(i.getProducto().getProductoPK().getTippro().equals(r.getIdPK().getTipsus())
                    && i.getProducto().getProductoPK().getArtcod().equals(r.getIdPK().getArtsus())){

                        r.setSeleccionado(true);
                    }                    
                }
            }
        }
        
    }

    public void marcarFavoritoEnProductoSeleccionado(Producto p){
        
        if (!usuarioSessionBean.isEstaRegistrado()) return;
        if (p==null) return;
        if (usuarioSessionBean.getUsuario().getFavoritos()==null) return;
        
        for(ProductoFavorito f: usuarioSessionBean.getUsuario().getFavoritos() ){

            if(f.getProducto().getProductoPK().getTippro().equals(p.getProductoPK().getTippro())
            && f.getProducto().getProductoPK().getArtcod().equals(p.getArtcod())){

                itemCatalogo.setFavorito(true);
            }            
        }        
    }
    
    public void verConfirmarCantidad(ItemCatalogo i){

        seleccionarItemCatalogo(i, true);
        JsfUtil.addInfoMessage("Ingrese un valor para cantidad mayor a 0");
    }
    
    public void verConfirmarCantidadProducto(Producto p){
        
        carritoBean.setBonificacion2(BigDecimal.ZERO);        
        generarItemCatalogo(p);        
        JsfUtil.addInfoMessage("Ingrese un valor para cantidad mayor a 0");
    }    
    
    public String verItemCatalogo(){
        return "../inventario/producto.xhtml?faces-redirect=true";
    }
        
    public String verFichaProducto(ItemCatalogo i){
        seleccionarItemCatalogo(i, true);        
        return verItemCatalogo();        
    }
    
    public String verFichaProductoFromProducto(Producto p){
        generarItemCatalogo(p);
        return verItemCatalogo();        
    }
    
    public String verFichaProductoFromFavoritos(Producto p){
        generarItemCatalogo(p);        
        return verItemCatalogo();
    }
    
    public void seleccionarItemCatalogo(ItemCatalogo i, boolean  actualizaProd){

        itemCatalogo = i;       

        if(actualizaProd){
            itemCatalogo.setProducto(productoRN.getProducto(i.getTippro(),i.getArtcod()));   
            
            if(itemCatalogo.getTieneSugeridos().equals("S")){
                itemCatalogo.getProducto().setRelacionados(productoRN.getProductosRelacionados(i.getTippro(), i.getArtcod(), false));
            }
            
            if(itemCatalogo.getTieneSustitutos().equals("S")){
                itemCatalogo.getProducto().setSustitutos(productoRN.getProductosSustitutos(i.getTippro(), i.getArtcod(), false));
            }            
            
            marcarProductoSeleccionado(itemCatalogo.getProducto());
            marcarFavoritoEnProductoSeleccionado(itemCatalogo.getProducto());
        }
    }

    public void verProductosPendientes(ItemCatalogo i){
        itemCatalogo = i;    
        itemCatalogo.setPedidosPendiente(movimientoFacturacionRN.getPendientePorPedidoProducto(nrocta,i.getTippro(),i.getArtcod()));
    }

    public void generarItemCatalogo(Producto p){
       
        //Si el producto se encuentra en el catalogo actual simplemente lo referencio
        if(catalogo!=null){
            for(ItemCatalogo i: catalogo){
                if(i.getArtcod().equals(p.getArtcod())&&i.getTippro().equals(p.getTippro())){
                    seleccionarItemCatalogo(i, true);                   
                    return;
                }
            }            
        }
        
        //Si no existe usuario logeado asignamos el usuario por defecto para visualizar el catálogo publico
        if (usuarioSessionBean.getUsuario().getCliente()==null){
            JsfUtil.addWarningMessage("Para visualizar los precios debe inciar sessión");
            nrocta = "999999";
        }else{
            nrocta = usuarioSessionBean.getUsuario().getCliente().getNrocta();
        }

        //Si el producto no esta en la seleccion, entonces busco en la bd
        itemCatalogo = listaPrecioRN.getItemCatalogoByProducto(p, nrocta);

        if(usuarioSessionBean.isEstaRegistrado()){
            if(itemCatalogo!=null){
                marcarProductoSeleccionado(itemCatalogo.getProducto());
                marcarFavoritoEnProductoSeleccionado(itemCatalogo.getProducto());
            }else{
                JsfUtil.addWarningMessage("El producto seleccionado no está disponible en estos momentos");
            }
        }               
    }
  
     //_-------------------------------------------------------------------------


    public List<ItemCatalogo> getCatalogo() {
        return catalogo;
    }

    public void setCatalogo(List<ItemCatalogo> catalogo) {
        this.catalogo = catalogo;
    }

    public CarritoBean getCarritoBean() {
        return carritoBean;
    }

    public void setCarritoBean(CarritoBean carritoBean) {
        this.carritoBean = carritoBean;
    }

    public String getTxtDescripcion() {
        return txtDescripcion;
    }

    public void setTxtDescripcion(String txtDescripcion) {
        this.txtDescripcion = txtDescripcion;
    }

    public String getMarca() {
        return marca;
    }

    public void setMarca(String marca) {
        this.marca = marca;
    }

    public boolean isImportado() {
        return importado;
    }

    public void setImportado(boolean importado) {
        this.importado = importado;
    }

    public boolean isNacional() {
        return nacional;
    }

    public void setNacional(boolean nacional) {
        this.nacional = nacional;
    }
    
    public String getSubTipo() {
        return subTipo;
    }

    public void setSubTipo(String subTipo) {
        this.subTipo = subTipo;
    }

    public String getTipoProducto() {
        return tipoProducto;
    }

    public void setTipoProducto(String tipoProducto) {
        this.tipoProducto = tipoProducto;
    }

    public List<String> getMarcas() {
        return marcas;
    }

    public void setMarcas(List<String> marcas) {
        this.marcas = marcas;
    }

    public List<String> getSubTipos() {
        return subTipos;
    }

    public void setSubTipos(List<String> subTipos) {
        this.subTipos = subTipos;
    }

    public List<String> getTiposProductos() {
        return tiposProductos;
    }

    public void setTiposProductos(List<String> tiposProductos) {
        this.tiposProductos = tiposProductos;
    }

    public UsuarioSessionBean getUsuarioSessionBean() {
        return usuarioSessionBean;
    }

    public void setUsuarioSessionBean(UsuarioSessionBean usuarioSessionBean) {
        this.usuarioSessionBean = usuarioSessionBean;
    }

    public int getCantidadRegistros() {

        return cantidadRegistros;
    }

    public void setCantidadRegistros(int cantidadRegistros) {
        this.cantidadRegistros = cantidadRegistros;
    }

    public BigDecimal getPorcMarcacion() {
        return porcMarcacion;
    }

    public void setPorcMarcacion(BigDecimal porcMarcacion) {
        this.porcMarcacion = porcMarcacion;
    }

    public Map<String, String> getFiltro() {
        return filtro;
    }

    public void setFiltro(Map<String, String> filtro) {
        this.filtro = filtro;
    }

    public String getSelecionActual() {
        return selecionActual;
    }

    public void setSelecionActual(String selecionActual) {
        this.selecionActual = selecionActual;
    }

    public ItemCatalogo getItemCatalogo() {
        return itemCatalogo;
    }

    public void setItemCatalogo(ItemCatalogo itemCatalogo) {
        this.itemCatalogo = itemCatalogo;
    }

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }

    public TreeNode getSelectedNode() {
        return selectedNode;
    }

    public void setSelectedNode(TreeNode selectedNode) {
        this.selectedNode = selectedNode;
    }

    public boolean isEsVendedor() {
        return esVendedor;
    }

    public void setEsVendedor(boolean esVendedor) {
        this.esVendedor = esVendedor;
    }

    public String getTipoVista() {
        return tipoVista;
    }

    public void setTipoVista(String tipoVista) {
        this.tipoVista = tipoVista;
    }

    public boolean isMuestraPrincipal() {
        return muestraPrincipal;
    }

    public void setMuestraPrincipal(boolean muestraPrincipal) {
        this.muestraPrincipal = muestraPrincipal;
    }
    
    public Map<String, String> getFiltroRubros() {
        return filtroRubros;
    }

    public void setFiltroRubros(Map<String, String> filtroRubros) {
        this.filtroRubros = filtroRubros;
    }

    public boolean isNuevo() {
        return nuevo;
    }

    public void setNuevo(boolean nuevo) {
        this.nuevo = nuevo;
    }
    
    public boolean isMuestraPanelMarcacion() {
        return muestraPanelMarcacion;
    }

    public void setMuestraPanelMarcacion(boolean muestraPanelMarcacion) {
        this.muestraPanelMarcacion = muestraPanelMarcacion;
    }

    public boolean isMuestraConversorMedida() {
        return muestraConversorMedida;
    }

    public void setMuestraConversorMedida(boolean muestraConversorMedida) {
        this.muestraConversorMedida = muestraConversorMedida;
    }

    public boolean isMuestraPanelDescarga() {
        return muestraPanelDescarga;
    }

    public void setMuestraPanelDescarga(boolean muestraPanelDescarga) {
        this.muestraPanelDescarga = muestraPanelDescarga;
    }

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public MonedaBean getMonedaBean() {
        return monedaBean;
    }

    public void setMonedaBean(MonedaBean monedaBean) {
        this.monedaBean = monedaBean;
    }

    public boolean isPrecioActualizado() {
        return precioActualizado;
    }

    public void setPrecioActualizado(boolean precioActualizado) {
        this.precioActualizado = precioActualizado;
    }

    public List<ItemBusquedaPredefinida> getItemsBusqueda() {
        return itemsBusqueda;
    }

    public void setItemsBusqueda(List<ItemBusquedaPredefinida> itemsBusqueda) {
        this.itemsBusqueda = itemsBusqueda;
    }
}
